home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / linux / blktrace_api.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  10.8 KB  |  374 lines
  1. #ifndef BLKTRACE_H
  2. #define BLKTRACE_H
  3.  
  4. #ifdef __KERNEL__
  5. #include <linux/blkdev.h>
  6. #include <linux/relay.h>
  7. #endif
  8.  
  9. /*
  10.  * Trace categories
  11.  */
  12. enum blktrace_cat {
  13.     BLK_TC_READ    = 1 << 0,    /* reads */
  14.     BLK_TC_WRITE    = 1 << 1,    /* writes */
  15.     BLK_TC_BARRIER    = 1 << 2,    /* barrier */
  16.     BLK_TC_SYNC    = 1 << 3,    /* sync IO */
  17.     BLK_TC_QUEUE    = 1 << 4,    /* queueing/merging */
  18.     BLK_TC_REQUEUE    = 1 << 5,    /* requeueing */
  19.     BLK_TC_ISSUE    = 1 << 6,    /* issue */
  20.     BLK_TC_COMPLETE    = 1 << 7,    /* completions */
  21.     BLK_TC_FS    = 1 << 8,    /* fs requests */
  22.     BLK_TC_PC    = 1 << 9,    /* pc requests */
  23.     BLK_TC_NOTIFY    = 1 << 10,    /* special message */
  24.     BLK_TC_AHEAD    = 1 << 11,    /* readahead */
  25.     BLK_TC_META    = 1 << 12,    /* metadata */
  26.     BLK_TC_DISCARD    = 1 << 13,    /* discard requests */
  27.     BLK_TC_DRV_DATA    = 1 << 14,    /* binary per-driver data */
  28.  
  29.     BLK_TC_END    = 1 << 15,    /* only 16-bits, reminder */
  30. };
  31.  
  32. #define BLK_TC_SHIFT        (16)
  33. #define BLK_TC_ACT(act)        ((act) << BLK_TC_SHIFT)
  34.  
  35. /*
  36.  * Basic trace actions
  37.  */
  38. enum blktrace_act {
  39.     __BLK_TA_QUEUE = 1,        /* queued */
  40.     __BLK_TA_BACKMERGE,        /* back merged to existing rq */
  41.     __BLK_TA_FRONTMERGE,        /* front merge to existing rq */
  42.     __BLK_TA_GETRQ,            /* allocated new request */
  43.     __BLK_TA_SLEEPRQ,        /* sleeping on rq allocation */
  44.     __BLK_TA_REQUEUE,        /* request requeued */
  45.     __BLK_TA_ISSUE,            /* sent to driver */
  46.     __BLK_TA_COMPLETE,        /* completed by driver */
  47.     __BLK_TA_PLUG,            /* queue was plugged */
  48.     __BLK_TA_UNPLUG_IO,        /* queue was unplugged by io */
  49.     __BLK_TA_UNPLUG_TIMER,        /* queue was unplugged by timer */
  50.     __BLK_TA_INSERT,        /* insert request */
  51.     __BLK_TA_SPLIT,            /* bio was split */
  52.     __BLK_TA_BOUNCE,        /* bio was bounced */
  53.     __BLK_TA_REMAP,            /* bio was remapped */
  54.     __BLK_TA_ABORT,            /* request aborted */
  55.     __BLK_TA_DRV_DATA,        /* driver-specific binary data */
  56. };
  57.  
  58. /*
  59.  * Notify events.
  60.  */
  61. enum blktrace_notify {
  62.     __BLK_TN_PROCESS = 0,        /* establish pid/name mapping */
  63.     __BLK_TN_TIMESTAMP,        /* include system clock */
  64.     __BLK_TN_MESSAGE,        /* Character string message */
  65. };
  66.  
  67.  
  68. /*
  69.  * Trace actions in full. Additionally, read or write is masked
  70.  */
  71. #define BLK_TA_QUEUE        (__BLK_TA_QUEUE | BLK_TC_ACT(BLK_TC_QUEUE))
  72. #define BLK_TA_BACKMERGE    (__BLK_TA_BACKMERGE | BLK_TC_ACT(BLK_TC_QUEUE))
  73. #define BLK_TA_FRONTMERGE    (__BLK_TA_FRONTMERGE | BLK_TC_ACT(BLK_TC_QUEUE))
  74. #define    BLK_TA_GETRQ        (__BLK_TA_GETRQ | BLK_TC_ACT(BLK_TC_QUEUE))
  75. #define    BLK_TA_SLEEPRQ        (__BLK_TA_SLEEPRQ | BLK_TC_ACT(BLK_TC_QUEUE))
  76. #define    BLK_TA_REQUEUE        (__BLK_TA_REQUEUE | BLK_TC_ACT(BLK_TC_REQUEUE))
  77. #define BLK_TA_ISSUE        (__BLK_TA_ISSUE | BLK_TC_ACT(BLK_TC_ISSUE))
  78. #define BLK_TA_COMPLETE        (__BLK_TA_COMPLETE| BLK_TC_ACT(BLK_TC_COMPLETE))
  79. #define BLK_TA_PLUG        (__BLK_TA_PLUG | BLK_TC_ACT(BLK_TC_QUEUE))
  80. #define BLK_TA_UNPLUG_IO    (__BLK_TA_UNPLUG_IO | BLK_TC_ACT(BLK_TC_QUEUE))
  81. #define BLK_TA_UNPLUG_TIMER    (__BLK_TA_UNPLUG_TIMER | BLK_TC_ACT(BLK_TC_QUEUE))
  82. #define BLK_TA_INSERT        (__BLK_TA_INSERT | BLK_TC_ACT(BLK_TC_QUEUE))
  83. #define BLK_TA_SPLIT        (__BLK_TA_SPLIT)
  84. #define BLK_TA_BOUNCE        (__BLK_TA_BOUNCE)
  85. #define BLK_TA_REMAP        (__BLK_TA_REMAP | BLK_TC_ACT(BLK_TC_QUEUE))
  86. #define BLK_TA_ABORT        (__BLK_TA_ABORT | BLK_TC_ACT(BLK_TC_QUEUE))
  87. #define BLK_TA_DRV_DATA    (__BLK_TA_DRV_DATA | BLK_TC_ACT(BLK_TC_DRV_DATA))
  88.  
  89. #define BLK_TN_PROCESS        (__BLK_TN_PROCESS | BLK_TC_ACT(BLK_TC_NOTIFY))
  90. #define BLK_TN_TIMESTAMP    (__BLK_TN_TIMESTAMP | BLK_TC_ACT(BLK_TC_NOTIFY))
  91. #define BLK_TN_MESSAGE        (__BLK_TN_MESSAGE | BLK_TC_ACT(BLK_TC_NOTIFY))
  92.  
  93. #define BLK_IO_TRACE_MAGIC    0x65617400
  94. #define BLK_IO_TRACE_VERSION    0x07
  95.  
  96. /*
  97.  * The trace itself
  98.  */
  99. struct blk_io_trace {
  100.     __u32 magic;        /* MAGIC << 8 | version */
  101.     __u32 sequence;        /* event number */
  102.     __u64 time;        /* in microseconds */
  103.     __u64 sector;        /* disk offset */
  104.     __u32 bytes;        /* transfer length */
  105.     __u32 action;        /* what happened */
  106.     __u32 pid;        /* who did it */
  107.     __u32 device;        /* device number */
  108.     __u32 cpu;        /* on what cpu did it happen */
  109.     __u16 error;        /* completion error */
  110.     __u16 pdu_len;        /* length of data after this trace */
  111. };
  112.  
  113. /*
  114.  * The remap event
  115.  */
  116. struct blk_io_trace_remap {
  117.     __be32 device;
  118.     __be32 device_from;
  119.     __be64 sector;
  120. };
  121.  
  122. enum {
  123.     Blktrace_setup = 1,
  124.     Blktrace_running,
  125.     Blktrace_stopped,
  126. };
  127.  
  128. #define BLKTRACE_BDEV_SIZE    32
  129.  
  130. /*
  131.  * User setup structure passed with BLKTRACESTART
  132.  */
  133. struct blk_user_trace_setup {
  134.     char name[BLKTRACE_BDEV_SIZE];    /* output */
  135.     __u16 act_mask;            /* input */
  136.     __u32 buf_size;            /* input */
  137.     __u32 buf_nr;            /* input */
  138.     __u64 start_lba;
  139.     __u64 end_lba;
  140.     __u32 pid;
  141. };
  142.  
  143. #ifdef __KERNEL__
  144. #if defined(CONFIG_BLK_DEV_IO_TRACE)
  145. struct blk_trace {
  146.     int trace_state;
  147.     struct rchan *rchan;
  148.     unsigned long *sequence;
  149.     unsigned char *msg_data;
  150.     u16 act_mask;
  151.     u64 start_lba;
  152.     u64 end_lba;
  153.     u32 pid;
  154.     u32 dev;
  155.     struct dentry *dir;
  156.     struct dentry *dropped_file;
  157.     struct dentry *msg_file;
  158.     atomic_t dropped;
  159. };
  160.  
  161. extern int blk_trace_ioctl(struct block_device *, unsigned, char __user *);
  162. extern void blk_trace_shutdown(struct request_queue *);
  163. extern void __blk_add_trace(struct blk_trace *, sector_t, int, int, u32, int, int, void *);
  164. extern int do_blk_trace_setup(struct request_queue *q,
  165.     char *name, dev_t dev, struct blk_user_trace_setup *buts);
  166. extern void __trace_note_message(struct blk_trace *, const char *fmt, ...);
  167.  
  168. /**
  169.  * blk_add_trace_msg - Add a (simple) message to the blktrace stream
  170.  * @q:        queue the io is for
  171.  * @fmt:    format to print message in
  172.  * args...    Variable argument list for format
  173.  *
  174.  * Description:
  175.  *     Records a (simple) message onto the blktrace stream.
  176.  *
  177.  *     NOTE: BLK_TN_MAX_MSG characters are output at most.
  178.  *     NOTE: Can not use 'static inline' due to presence of var args...
  179.  *
  180.  **/
  181. #define blk_add_trace_msg(q, fmt, ...)                    \
  182.     do {                                \
  183.         struct blk_trace *bt = (q)->blk_trace;            \
  184.         if (unlikely(bt))                    \
  185.             __trace_note_message(bt, fmt, ##__VA_ARGS__);    \
  186.     } while (0)
  187. #define BLK_TN_MAX_MSG        128
  188.  
  189. /**
  190.  * blk_add_trace_rq - Add a trace for a request oriented action
  191.  * @q:        queue the io is for
  192.  * @rq:        the source request
  193.  * @what:    the action
  194.  *
  195.  * Description:
  196.  *     Records an action against a request. Will log the bio offset + size.
  197.  *
  198.  **/
  199. static inline void blk_add_trace_rq(struct request_queue *q, struct request *rq,
  200.                     u32 what)
  201. {
  202.     struct blk_trace *bt = q->blk_trace;
  203.     int rw = rq->cmd_flags & 0x03;
  204.  
  205.     if (likely(!bt))
  206.         return;
  207.  
  208.     if (blk_discard_rq(rq))
  209.         rw |= (1 << BIO_RW_DISCARD);
  210.  
  211.     if (blk_pc_request(rq)) {
  212.         what |= BLK_TC_ACT(BLK_TC_PC);
  213.         __blk_add_trace(bt, 0, rq->data_len, rw, what, rq->errors, sizeof(rq->cmd), rq->cmd);
  214.     } else  {
  215.         what |= BLK_TC_ACT(BLK_TC_FS);
  216.         __blk_add_trace(bt, rq->hard_sector, rq->hard_nr_sectors << 9, rw, what, rq->errors, 0, NULL);
  217.     }
  218. }
  219.  
  220. /**
  221.  * blk_add_trace_bio - Add a trace for a bio oriented action
  222.  * @q:        queue the io is for
  223.  * @bio:    the source bio
  224.  * @what:    the action
  225.  *
  226.  * Description:
  227.  *     Records an action against a bio. Will log the bio offset + size.
  228.  *
  229.  **/
  230. static inline void blk_add_trace_bio(struct request_queue *q, struct bio *bio,
  231.                      u32 what)
  232. {
  233.     struct blk_trace *bt = q->blk_trace;
  234.  
  235.     if (likely(!bt))
  236.         return;
  237.  
  238.     __blk_add_trace(bt, bio->bi_sector, bio->bi_size, bio->bi_rw, what, !bio_flagged(bio, BIO_UPTODATE), 0, NULL);
  239. }
  240.  
  241. /**
  242.  * blk_add_trace_generic - Add a trace for a generic action
  243.  * @q:        queue the io is for
  244.  * @bio:    the source bio
  245.  * @rw:        the data direction
  246.  * @what:    the action
  247.  *
  248.  * Description:
  249.  *     Records a simple trace
  250.  *
  251.  **/
  252. static inline void blk_add_trace_generic(struct request_queue *q,
  253.                      struct bio *bio, int rw, u32 what)
  254. {
  255.     struct blk_trace *bt = q->blk_trace;
  256.  
  257.     if (likely(!bt))
  258.         return;
  259.  
  260.     if (bio)
  261.         blk_add_trace_bio(q, bio, what);
  262.     else
  263.         __blk_add_trace(bt, 0, 0, rw, what, 0, 0, NULL);
  264. }
  265.  
  266. /**
  267.  * blk_add_trace_pdu_int - Add a trace for a bio with an integer payload
  268.  * @q:        queue the io is for
  269.  * @what:    the action
  270.  * @bio:    the source bio
  271.  * @pdu:    the integer payload
  272.  *
  273.  * Description:
  274.  *     Adds a trace with some integer payload. This might be an unplug
  275.  *     option given as the action, with the depth at unplug time given
  276.  *     as the payload
  277.  *
  278.  **/
  279. static inline void blk_add_trace_pdu_int(struct request_queue *q, u32 what,
  280.                      struct bio *bio, unsigned int pdu)
  281. {
  282.     struct blk_trace *bt = q->blk_trace;
  283.     __be64 rpdu = cpu_to_be64(pdu);
  284.  
  285.     if (likely(!bt))
  286.         return;
  287.  
  288.     if (bio)
  289.         __blk_add_trace(bt, bio->bi_sector, bio->bi_size, bio->bi_rw, what, !bio_flagged(bio, BIO_UPTODATE), sizeof(rpdu), &rpdu);
  290.     else
  291.         __blk_add_trace(bt, 0, 0, 0, what, 0, sizeof(rpdu), &rpdu);
  292. }
  293.  
  294. /**
  295.  * blk_add_trace_remap - Add a trace for a remap operation
  296.  * @q:        queue the io is for
  297.  * @bio:    the source bio
  298.  * @dev:    target device
  299.  * @from:    source sector
  300.  * @to:        target sector
  301.  *
  302.  * Description:
  303.  *     Device mapper or raid target sometimes need to split a bio because
  304.  *     it spans a stripe (or similar). Add a trace for that action.
  305.  *
  306.  **/
  307. static inline void blk_add_trace_remap(struct request_queue *q, struct bio *bio,
  308.                        dev_t dev, sector_t from, sector_t to)
  309. {
  310.     struct blk_trace *bt = q->blk_trace;
  311.     struct blk_io_trace_remap r;
  312.  
  313.     if (likely(!bt))
  314.         return;
  315.  
  316.     r.device = cpu_to_be32(dev);
  317.     r.device_from = cpu_to_be32(bio->bi_bdev->bd_dev);
  318.     r.sector = cpu_to_be64(to);
  319.  
  320.     __blk_add_trace(bt, from, bio->bi_size, bio->bi_rw, BLK_TA_REMAP, !bio_flagged(bio, BIO_UPTODATE), sizeof(r), &r);
  321. }
  322.  
  323. /**
  324.  * blk_add_driver_data - Add binary message with driver-specific data
  325.  * @q:        queue the io is for
  326.  * @rq:        io request
  327.  * @data:    driver-specific data
  328.  * @len:    length of driver-specific data
  329.  *
  330.  * Description:
  331.  *     Some drivers might want to write driver-specific data per request.
  332.  *
  333.  **/
  334. static inline void blk_add_driver_data(struct request_queue *q,
  335.                        struct request *rq,
  336.                        void *data, size_t len)
  337. {
  338.     struct blk_trace *bt = q->blk_trace;
  339.  
  340.     if (likely(!bt))
  341.         return;
  342.  
  343.     if (blk_pc_request(rq))
  344.         __blk_add_trace(bt, 0, rq->data_len, 0, BLK_TA_DRV_DATA,
  345.                 rq->errors, len, data);
  346.     else
  347.         __blk_add_trace(bt, rq->hard_sector, rq->hard_nr_sectors << 9,
  348.                 0, BLK_TA_DRV_DATA, rq->errors, len, data);
  349. }
  350.  
  351. extern int blk_trace_setup(struct request_queue *q, char *name, dev_t dev,
  352.                char __user *arg);
  353. extern int blk_trace_startstop(struct request_queue *q, int start);
  354. extern int blk_trace_remove(struct request_queue *q);
  355.  
  356. #else /* !CONFIG_BLK_DEV_IO_TRACE */
  357. #define blk_trace_ioctl(bdev, cmd, arg)        (-ENOTTY)
  358. #define blk_trace_shutdown(q)            do { } while (0)
  359. #define blk_add_trace_rq(q, rq, what)        do { } while (0)
  360. #define blk_add_trace_bio(q, rq, what)        do { } while (0)
  361. #define blk_add_trace_generic(q, rq, rw, what)    do { } while (0)
  362. #define blk_add_trace_pdu_int(q, what, bio, pdu)    do { } while (0)
  363. #define blk_add_trace_remap(q, bio, dev, f, t)    do {} while (0)
  364. #define blk_add_driver_data(q, rq, data, len)    do {} while (0)
  365. #define do_blk_trace_setup(q, name, dev, buts)    (-ENOTTY)
  366. #define blk_trace_setup(q, name, dev, arg)    (-ENOTTY)
  367. #define blk_trace_startstop(q, start)        (-ENOTTY)
  368. #define blk_trace_remove(q)            (-ENOTTY)
  369. #define blk_add_trace_msg(q, fmt, ...)        do { } while (0)
  370.  
  371. #endif /* CONFIG_BLK_DEV_IO_TRACE */
  372. #endif /* __KERNEL__ */
  373. #endif
  374.